home *** CD-ROM | disk | FTP | other *** search
/ Whiteline: delta / whiteline CD Series - delta.iso / tex / tools / dvi_300b / treiber / sources / treiber.c < prev    next >
C/C++ Source or Header  |  1995-11-25  |  7KB  |  350 lines
  1. #include <signal.h>
  2. #include <atarierr.h>
  3.  
  4. #ifdef __GNUC__
  5.  
  6. #include <fcntl.h>
  7. #include <ioctl.h>
  8. #include <osbind.h>
  9. #include <mintbind.h>
  10.  
  11. #else
  12. #ifdef __TURBOC__
  13.  
  14. #include <tos.h>
  15. #include "mintbind.h"
  16.  
  17. #else
  18.  
  19. #include <osbind.h>
  20. #include "mintbind.h"
  21.  
  22. #endif
  23. #endif
  24.  
  25.  
  26. #include <stdlib.h>
  27. #include <string.h>
  28.  
  29. #include "treiber.h"
  30.  
  31. #define FALSE 0
  32. #define TRUE 1
  33.  
  34. /********************************************************************/
  35. /* Externe routinen in Assembler (FAST_DVI.S) */
  36.  
  37. #ifdef FAST_PRN
  38. extern long    prn_byte( char *ptr, long byte );
  39. extern void    exstall( void );
  40. #endif
  41.  
  42. extern volatile long    old_vec;
  43. /* 22.1.93 */
  44.  
  45. /********************************************************************/
  46.  
  47. /* Pufferspeicher */
  48. static char    *puffer, *druck_puffer;
  49. extern long    max_puffer_laenge;    /* Kann vom Programm modifiziert werden */
  50. static long    puffer_laenge = 0L;
  51. static char signal_installed=FALSE;
  52.  
  53. /* Shared Memory */
  54. char                shm_name[128];
  55. static int    shm;
  56. static char    *memory;
  57.  
  58. /* Name des temporären Files */
  59. char                 tmp_file[256];
  60. long                MiNT;
  61.  
  62. #ifdef SHOW_PRT
  63. char    *disp_status="\033Hp";
  64. char    *char_status="/-\\|"; /* Kann man auch durch vier eigene Symbole ersetzen */
  65. char    rot_status;
  66. #endif
  67.  
  68. /********************************************************************/
  69. /* Einige Routinen zum Druck */
  70.  
  71. void    disp_prn( void *ptr, long len )
  72. {
  73.     if(  !signal_installed  )
  74.     {
  75.         signal_installed = TRUE;
  76.         Psignal( SIGINT, (long)exstall );
  77.         Psignal( SIGTERM, (long)exstall );
  78.     }
  79.     while(  prn_byte( ptr, len  )  )
  80.     {
  81.         (void)Fselect( 500, 0L, 0L, 0L );
  82. #ifdef SHOW_PRT
  83.         disp_status[2] = char_status[rot_status++];
  84.         rot_status &= 3;
  85.         Cconws( disp_status );
  86. #endif
  87.     }
  88. }
  89. /* 10.9.94 */
  90.  
  91.  
  92. void    disp_wait( void )
  93. {
  94.     while(  old_vec!=0L  )
  95.     {
  96.         (void)Fselect( 500, 0L, 0L, 0L );
  97. #ifdef SHOW_PRT
  98.         disp_status[2] = char_status[rot_status++];
  99.         rot_status &= 3;
  100.         Cconws( disp_status );
  101. #endif
  102.     }
  103. }
  104.  
  105.  
  106.     /* Gibt Puffer aus (SCHNELL!!) */
  107. void    flush_block( int fh )
  108. {
  109.     if(  fh>0  )
  110.     {
  111.         Fclose( fh );
  112.         return;
  113.     }
  114.     if(  puffer_laenge>0  )
  115.     {
  116.         disp_wait();
  117.         memcpy( druck_puffer, puffer, puffer_laenge );
  118.         disp_prn( druck_puffer, puffer_laenge );
  119.     }
  120.     puffer_laenge = 0;
  121. }
  122. /* 23.1.93 */
  123.  
  124.  
  125.  
  126.     /* Gibt an aus (SCHNELL! über Spooler) */
  127. long    print_block( long laenge, char *blk, int fh )
  128. {
  129.     if(  fh>0  )
  130.     {
  131. #ifdef SHOW_PRT
  132.         disp_status[2] = char_status[rot_status++];
  133.         rot_status &= 3;
  134.         Cconws( disp_status );
  135. #endif
  136.         return Fwrite( fh, laenge, blk );
  137.     }
  138.     if(  laenge+puffer_laenge>=max_puffer_laenge  )
  139.     {
  140.         disp_wait();
  141.         if(  puffer_laenge>0  )
  142.         {
  143.             memcpy( druck_puffer, puffer, puffer_laenge );
  144.             disp_prn( druck_puffer, puffer_laenge );
  145.         }
  146.         puffer_laenge = 0L;
  147.     }
  148.  
  149.         /* Zu lang... */
  150.     if(  laenge>=max_puffer_laenge  )
  151.     {
  152.         disp_prn( blk, laenge );
  153.         disp_wait();
  154.     }
  155.     else
  156.     {
  157.         memcpy( puffer+puffer_laenge, blk, laenge );
  158.         puffer_laenge += laenge;
  159.     }
  160.     return laenge;
  161. }
  162. /* 22.1.93 */
  163.  
  164.  
  165. long    print_str( char *str, int fh )
  166. {
  167.     return print_block( strlen(str), str, fh );
  168. }
  169. /* 3.9.94 */
  170.  
  171.  
  172.  
  173. /* Versucht Drucker zu Öffnen und zu Verriegeln! */ 
  174. int    open_printer( int devh )
  175. {
  176.     puffer = druck_puffer = 0L;
  177.     if(  devh<0  &&  max_puffer_laenge>128  )
  178.     {
  179.         puffer = Malloc( max_puffer_laenge );    /* Speicher holen */
  180.         if(  puffer<=0L  )
  181.             return 0;    /* Out of Memory */
  182.         druck_puffer = Malloc( max_puffer_laenge );
  183.         if(  druck_puffer<=0L  )
  184.         {
  185.             Mfree( puffer );
  186.             return 0;    /* Out of Memory */
  187.         }
  188.     }
  189.  
  190.     /* Druckersemaphore bekommen! (Wird bei Beendigung automatisch frei) */
  191.     devh = (int)Psemaphore( 0, 0x50524E3AL /*PRN:*/, -1 /*Kein Timeout*/ );
  192.     if(  devh!=0  )
  193.         Psemaphore( 2, 0x50524E3AL /*PRN:*/, -1 /*Kein Timeout*/ );
  194.  
  195. #ifdef SHOW_PRT
  196.     disp_status[2] = '|';
  197.     Cconws( disp_status );
  198. #endif
  199.  
  200.     return 1;    /* Erfolg */
  201. }
  202. /* 6.2.93 */
  203.  
  204.  
  205.  
  206. /********************************************************************/
  207. /* Routinen für Optimierung */
  208.  
  209.  
  210. /* Ist diese Zeile Leerzeile? */
  211. int    ist_leerzeile( char *ptr, long offset )
  212. {
  213.     long    i;
  214.     for(  i=0;  i<offset;  i++  )
  215.         if(  *ptr++!=0  )
  216.             return FALSE;
  217.     return TRUE;
  218. }
  219. /* 16.1.93 */
  220.  
  221.  
  222.  
  223. /* Sind in den nächsten #next Zeilen Zeichen? */
  224. int    ist_next_leer( char *ptr, long offset, long next )
  225. {
  226.     while(  next-->0  )
  227.     {
  228.         if(  *ptr!=0  )
  229.             return FALSE;
  230.         ptr += offset;
  231.     }
  232.     return TRUE;
  233. }
  234. /* 16.1.93 */
  235.  
  236.  
  237.  
  238. /********************************************************************/
  239. /* Hauptprogramm */
  240.  
  241.  
  242. int    main( int argc, const char *argv[] )
  243. {
  244.     long    x;
  245.     int        ret, th, flag, quer=0;
  246.     char    optionen[16];
  247.  
  248.     if(  argc<6  )
  249.     {
  250.         Cconws( "Zuwenig Argumente!\xD\xA" );
  251.         Cconws( "Richtig: shared_mem_file -Offset -l(=landscape, sonst -0) weite hoehe hdpi vdpi (file) (-\"Optionen) \xD\xA" );
  252.         return -1;
  253.     }
  254.  
  255.     th = -3;    /* Nix geöffnet! */
  256.     old_vec = 0L;    /* Keine Routine installiert */
  257.  
  258.         /* Diese Routine mit Parameter versehen! */
  259.         /* Es wird mit Shared Memory gearbeitet */
  260.         /* Wenn der erste Buchstabe eine Zahl ist, */
  261.         /* dann wird diese als Adresse angenommen */
  262.     strcpy( shm_name, (char *)argv[1] );
  263.     if(  shm_name[0]>='0'  &&  shm_name[0]<='9'  )
  264.     {
  265.         memory = (char *)atol( shm_name );
  266.         shm_name[0] = 0;
  267.     }
  268.     else
  269.     {
  270.         (long)memory = Fopen( shm_name, O_RDONLY );
  271.         if(  memory<0L  )
  272.             return (int)memory; /* Access denied */
  273.         shm = (int)memory;
  274.         memory = (char *)Fcntl( shm, 0L, SHMGETBLK );
  275.     }
  276.     if(  memory<=0  )
  277.         return -33;
  278.  
  279.     tmp_file[0] = 0;
  280.     quer = 0;
  281.     flag = 7;
  282.     /* Mehrere Teile */
  283.     x = -atol(argv[2]);
  284.     /* Mehrere Teile */
  285.     if(  argv[3][1]!='1'  )
  286.         flag = 2;
  287.     if(  x==0  )
  288.         flag |= 1;
  289.     if(  argv[3][2]=='l'  )
  290.         quer = 1;
  291.  
  292.     /* Evt. Zieldatei öffnen */
  293.     if(  argc>8  )
  294.     {
  295.         if(  argv[8][0]=='-'  )
  296.             strcpy( optionen, argv[9]+2 );
  297.         else
  298.         {
  299.             strcpy( tmp_file, argv[8] );
  300.             th = (int)Fopen( tmp_file, O_RDWR );
  301.             if(  th<0  )
  302.                 th = (int)Fcreate( tmp_file, 0 );
  303.             Fseek( 0, th, 2 );
  304.             if(  argc>9  )
  305.                 strcpy( optionen, argv[10]+2 );
  306.         }
  307.     }
  308. #ifndef FAST_PRN
  309.     else
  310.         th = (short)Fopen( "PRN:", O_RDONLY );
  311. #endif
  312.  
  313.  
  314.     /* Druckerinitialisierung */
  315.     while(  max_puffer_laenge>0  &&  !open_printer(th)  )
  316.     {
  317.         max_puffer_laenge >>= 1;
  318.         if(  max_puffer_laenge<=128L  )
  319.             return -39;    /* Zu wenig Speicher */
  320.     }
  321.  
  322.  
  323.         /* Und endlich drucken */
  324.     if(  (long)memory==1L  )
  325.         ret = drucke( 0L, 0, 0, 0, 0, 0, th, 4, quer, optionen );
  326.     else
  327.         ret = drucke( memory, x, atol(argv[4]), atol(argv[5]), atol(argv[6]), atol(argv[7]), th, flag, quer, optionen );
  328.  
  329.     if(  shm>0  )
  330.     {
  331.         Fclose( shm );
  332.         Mfree( memory );    /* so kann der Speicher wieder freigegeben werden */
  333.         Fdelete( shm_name );
  334.         shm = 0;
  335.     }
  336.  
  337.     if(  ret>=0  )    /* Erfolgreich? */
  338.     {
  339.         disp_wait();
  340.         /* Nur Datei erzeugen? */
  341.         if(  th>0  )
  342.             Fclose( th );
  343.         Cconws( "\033H " );
  344.         return 0;
  345.     }
  346.  
  347.     return ret;
  348. }
  349. /* 17.1.93 */
  350.